import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
 
df = pd.read_csv('data/images_analyzed_productivity1.csv')
df.head()

sizes = df['Productivity'].value_counts(sort=1)
sizes

df.drop(['Images_Analyzed'], axis=1, inplace=True)
df.drop(['User'], axis=1, inplace=True)
df.head()

df = df.dropna()

df.Productivity[df.Productivity == 'Good'] = 1
df.Productivity[df.Productivity == 'Bad'] = 2
df.head()

Y = df['Productivity'].values
Y = Y.astype('int')
Y

X = df.drop(labels=['Productivity'], axis=1)

from sklearn.model_selection import train_test_split
 
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.4, random_state=20)

from sklearn.ensemble import RandomForestClassifier
 
model = RandomForestClassifier(n_estimators=10, random_state=30)
model.fit(X_train, Y_train)
prediction_test = model.predict(X_test)
prediction_test

from sklearn import metrics
 
print('Accuracy =', metrics.accuracy_score(Y_test, prediction_test))

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=20)
model = RandomForestClassifier(n_estimators=10, random_state=30)
model.fit(X_train, Y_train)
prediction_test = model.predict(X_test)
prediction_test
print('Accuracy =', metrics.accuracy_score(Y_test, prediction_test))

feature_list = list(X.columns)
feature_imp = pd.Series(model.feature_importances_, index=feature_list).sort_values(ascending=False)
feature_imp

from IPython.display import HTML, display
from sklearn import tree
import pydotplus
 
estimators = model.estimators_
for m in estimators:
    dot_data = tree.export_graphviz(m, out_file=None,
                         feature_names=['Time', 'Coffee', 'Age'],
                         class_names=['Good', 'Bad'],
                         filled=True, rounded=True,
                         special_characters=True)
    graph = pydotplus.graph_from_dot_data(dot_data)
# 使用 ipython 的终端 jupyter notebook 显示。
svg = graph.create_svg()
if hasattr(svg, "decode"):
     svg = svg.decode("utf-8")
html = HTML(svg)
display(html)

import numpy as np
import cv2
import matplotlib.pyplot as plt
import pandas as pd

img = cv2.imread('images/synthetic.jpg', 0)

df = pd.DataFrame()
img2 = img.reshape(-1)
df['Original Pixels'] = img2
df

num = 1
for sigma in (3, 5):
    for theta in range(2):
        theta = theta / 4. * np.pi
        for lamda in np.arange(0, np.pi, np.pi / 4.):
            for gamma in (0.05, 0.5):
                gabor_label = 'Gabor ' + str(num)
                kernel = cv2.getGaborKernel((5, 5), sigma, theta, lamda, gamma, 0, ktype=cv2.CV_32F)
                fimg = cv2.filter2D(img, cv2.CV_8UC3, kernel)
                filtered_img = fimg.reshape(-1)
                df[gabor_label] = filtered_img
                num += 1

df.head()

df.to_csv('Gabor.csv')

import numpy as np
import cv2
import pandas as pd
import matplotlib.pyplot as plt
 
img = cv2.imread('images/Train_images/Sandstone_Versa0000.tif', 0)
plt.imshow(img, cmap='gray')

df = pd.DataFrame()

img2 = img.reshape(-1)
df['Original Image'] = img2
df.head()

# Generate Gabor features
num = 1  # To count numbers up in order to give Gabor features a lable in the data frame
kernels = []
for theta in range(2):  # Define number of thetas
    theta = theta / 4. * np.pi
    for sigma in (1, 3):  # Sigma with 1 and 3
        for lamda in np.arange(0, np.pi, np.pi / 4):  # Range of wavelengths
            for gamma in (0.05, 0.5):  # Gamma values of 0.05 and 0.5
                gabor_label = 'Gabor' + str(num)  # Label Gabor columns as Gabor1, Gabor2, etc.
                ksize = 9
                kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta, lamda, gamma, 0, ktype=cv2.CV_32F)    
                kernels.append(kernel)
                # Now filter the image and add values to a new column 
                fimg = cv2.filter2D(img2, cv2.CV_8UC3, kernel)
                filtered_img = fimg.reshape(-1)
                df[gabor_label] = filtered_img  # Labels columns as Gabor1, Gabor2, etc.
                print(gabor_label, ': theta =', theta, ': sigma =', sigma, ': lamda =', lamda, ': gamma =', gamma)
                num += 1  # Increment for gabor column label

edges = cv2.Canny(img, 100, 200)
edges1 = edges.reshape(-1)
df['Canny Edge'] = edges1

from skimage.filters import roberts, sobel, scharr, prewitt
 
edge_roberts = roberts(img)
edge_roberts1 = edge_roberts.reshape(-1)
df['Roberts'] = edge_roberts1

edge_sobel = sobel(img)
edge_sobel1 = edge_sobel.reshape(-1)
df['Sobel'] = edge_sobel1

edge_scharr = scharr(img)
edge_scharr1 = edge_scharr.reshape(-1)
df['Scharr'] = edge_scharr1

edge_prewitt = prewitt(img)
edge_prewitt1 = edge_prewitt.reshape(-1)
df['Prewitt'] = edge_prewitt1

from scipy import ndimage as nd
 
gaussian_img = nd.gaussian_filter(img, sigma=3)
gaussian_img1 = gaussian_img.reshape(-1)
df['Gaussian s3'] = gaussian_img1

gaussian_img2 = nd.gaussian_filter(img, sigma=7)
gaussian_img3 = gaussian_img2.reshape(-1)
df['Gaussian s7'] = gaussian_img3

median_img = nd.median_filter(img, size=3)
median_img1 = median_img.reshape(-1)
df['Median s3'] = median_img1

variance_img = nd.generic_filter(img, np.var, size=3)
variance_img1 = variance_img.reshape(-1)
df['Variance s3'] = variance_img1  # Add column to original dataframe

df.head()

labeled_img = cv2.imread('images/Train_masks/Sandstone_Versa0000.tif', 0)
labeled_img1 = labeled_img.reshape(-1)
df['Label'] = labeled_img1

Y = df['Label'].values
X = df.drop(labels=['Label'], axis=1)

from sklearn.model_selection import train_test_split
 
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.4, random_state=20)

from sklearn.ensemble import RandomForestClassifier
 
model = RandomForestClassifier(n_estimators=10, random_state=42)
model.fit(X_train, Y_train)
prediction_test = model.predict(X_test)

from sklearn import metrics
 
print("Accuracy =", metrics.accuracy_score(Y_test, prediction_test))

fig = plt.figure(figsize=(12, 16))
p = 1
for index, feature in enumerate(df.columns):
    if index == 0:
        p += 1
        ax = fig.add_subplot(181)
        plt.xticks([])
        plt.yticks([])
        ax.imshow(img, cmap='gray')
        ax.title.set_text(feature)
    else:
        if p % 8 == 1:
            p += 1
        exec("ax" + str(index) + "=fig.add_subplot(6, 8, " + str(p) + ")")
        plt.xticks([])
        plt.yticks([])
        exec("ax" + str(index) + ".imshow(np.array(df[feature]).reshape(img.shape), cmap='gray')")
        exec("ax" + str(index) + ".title.set_text('" + feature + "')")
        p += 1
plt.show()

importances = list(model.feature_importances_)
features_list = list(X.columns)
feature_imp = pd.Series(model.feature_importances_, index=features_list).sort_values(ascending=False)
feature_imp

import pickle
 
filename = 'sandstone_model'
pickle.dump(model, open(filename, 'wb'))
 
load_model = pickle.load(open(filename, 'rb'))
result = load_model.predict(X)
 
segmented = result.reshape((img.shape))

import matplotlib.pyplot as plt
 
plt.imshow(segmented, cmap='jet')

plt.imsave('segmented_rock.jpg', segmented, cmap='jet')

import numpy as np
import cv2
import pandas as pd
 
def feature_extraction(img):
    df = pd.DataFrame()
 
 
# All features generated must match the way features are generated for TRAINING.
# Feature1 is our original image pixels
    img2 = img.reshape(-1)
    df['Original Image'] = img2
 
# Generate Gabor features
    num = 1
    kernels = []
    for theta in range(2):
        theta = theta / 4. * np.pi
        for sigma in (1, 3):
            for lamda in np.arange(0, np.pi, np.pi / 4):
                for gamma in (0.05, 0.5):      
                    gabor_label = 'Gabor' + str(num)
                    ksize=9
                    kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta, lamda, gamma, 0, ktype=cv2.CV_32F)    
                    kernels.append(kernel)
                    # Now filter image and add values to new column
                    fimg = cv2.filter2D(img2, cv2.CV_8UC3, kernel)
                    filtered_img = fimg.reshape(-1)
                    df[gabor_label] = filtered_img  # Modify this to add new column for each gabor
                    num += 1
    ########################################
    # Geerate OTHER FEATURES and add them to the data frame
    # Feature 3 is canny edge
    edges = cv2.Canny(img, 100,200)   # Image, min and max values
    edges1 = edges.reshape(-1)
    df['Canny Edge'] = edges1  # Add column to original dataframe
 
    from skimage.filters import roberts, sobel, scharr, prewitt
 
    # Feature 4 is Roberts edge
    edge_roberts = roberts(img)
    edge_roberts1 = edge_roberts.reshape(-1)
    df['Roberts'] = edge_roberts1
 
    # Feature 5 is Sobel
    edge_sobel = sobel(img)
    edge_sobel1 = edge_sobel.reshape(-1)
    df['Sobel'] = edge_sobel1
 
    # Feature 6 is Scharr
    edge_scharr = scharr(img)
    edge_scharr1 = edge_scharr.reshape(-1)
    df['Scharr'] = edge_scharr1
 
    # Feature 7 is Prewitt
    edge_prewitt = prewitt(img)
    edge_prewitt1 = edge_prewitt.reshape(-1)
    df['Prewitt'] = edge_prewitt1
 
    # Feature 8 is Gaussian with sigma=3
    from scipy import ndimage as nd
    gaussian_img = nd.gaussian_filter(img, sigma=3)
    gaussian_img1 = gaussian_img.reshape(-1)
    df['Gaussian s3'] = gaussian_img1
 
    # Feature 9 is Gaussian with sigma=7
    gaussian_img2 = nd.gaussian_filter(img, sigma=7)
    gaussian_img3 = gaussian_img2.reshape(-1)
    df['Gaussian s7'] = gaussian_img3
 
    # Feature 10 is Median with sigma=3
    median_img = nd.median_filter(img, size=3)
    median_img1 = median_img.reshape(-1)
    df['Median s3'] = median_img1
 
    # Feature 11 is Variance with size=3
    variance_img = nd.generic_filter(img, np.var, size=3)
    variance_img1 = variance_img.reshape(-1)
    df['Variance s3'] = variance_img1  # Add column to original dataframe
 
    return df

import glob
import pickle
from matplotlib import pyplot as plt
 
filename = "sandstone_model"
loaded_model = pickle.load(open(filename, 'rb'))
 
path = "images/Train_images/*.tif"
for file in glob.glob(path):
    print(file)  # just stop here to see all file names printed
    img = cv2.imread(file, 0)
    # Call the feature extraction function.
    X = feature_extraction(img)
    result = loaded_model.predict(X)
    segmented = result.reshape((img.shape))
    
    name = file.split("e_")
    cv2.imwrite('images/Segmented/'+ name[1], segmented)

import numpy as np
import cv2
import pandas as pd
import pickle
from matplotlib import pyplot as plt
import os

image_dataset = pd.DataFrame()  # Dataframe to capture image features
 
img_path = "images/train_images/"
for image in os.listdir(img_path):  # iterate through each file 
    print(image)
    
    df = pd.DataFrame()  # Temporary data frame to capture information for each loop.
    # Reset dataframe to blank after each loop.
    
    input_img = cv2.imread(img_path + image)  # Read images
    
    # Check if the input image is RGB or grey and convert to grey if RGB
    if input_img.ndim == 3 and input_img.shape[-1] == 3:
        img = cv2.cvtColor(input_img,cv2.COLOR_BGR2GRAY)
    elif input_img.ndim == 2:
        img = input_img
    else:
        raise excerption("The module works only with grayscale and RGB images!")
 
################################################################
# START ADDING DATA TO THE DATAFRAME
 
    # Add pixel values to the data frame
    pixel_values = img.reshape(-1)
    df['Pixel_Value'] = pixel_values  # Pixel value itself as a feature
    df['Image_Name'] = image  # Capture image name as we read multiple images
    
############################################################################    
    # Generate Gabor features
    num = 1  # To count numbers up in order to give Gabor features a lable in the data frame
    kernels = []
    for theta in range(2):   # Define number of thetas
        theta = theta / 4. * np.pi
        for sigma in (1, 3):  # Sigma with 1 and 3
            for lamda in np.arange(0, np.pi, np.pi / 4):   # Range of wavelengths
                for gamma in (0.05, 0.5):  # Gamma values of 0.05 and 0.5
                    gabor_label = 'Gabor' + str(num)  # Label Gabor columns as Gabor1, Gabor2, etc.
                    ksize=9
                    kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta, lamda, gamma, 0, ktype=cv2.CV_32F)    
                    kernels.append(kernel)
                    # Now filter the image and add values to a new column 
                    fimg = cv2.filter2D(img, cv2.CV_8UC3, kernel)
                    filtered_img = fimg.reshape(-1)
                    df[gabor_label] = filtered_img  #Labels columns as Gabor1, Gabor2, etc.
                    print(gabor_label, ': theta=', theta, ': sigma=', sigma, ': lamda=', lamda, ': gamma=', gamma)
                    num += 1  # Increment for gabor column label
########################################
# Gerate OTHER FEATURES and add them to the data frame
                
    # CANNY EDGE
    edges = cv2.Canny(img, 100,200)   #Image, min and max values
    edges1 = edges.reshape(-1)
    df['Canny Edge'] = edges1 #Add column to original dataframe
    
    from skimage.filters import roberts, sobel, scharr, prewitt
    
    # ROBERTS EDGE
    edge_roberts = roberts(img)
    edge_roberts1 = edge_roberts.reshape(-1)
    df['Roberts'] = edge_roberts1
    
    # SOBEL
    edge_sobel = sobel(img)
    edge_sobel1 = edge_sobel.reshape(-1)
    df['Sobel'] = edge_sobel1
    
    # SCHARR
    edge_scharr = scharr(img)
    edge_scharr1 = edge_scharr.reshape(-1)
    df['Scharr'] = edge_scharr1
    
    # PREWITT
    edge_prewitt = prewitt(img)
    edge_prewitt1 = edge_prewitt.reshape(-1)
    df['Prewitt'] = edge_prewitt1
    
    # GAUSSIAN with sigma=3
    from scipy import ndimage as nd
    gaussian_img = nd.gaussian_filter(img, sigma=3)
    gaussian_img1 = gaussian_img.reshape(-1)
    df['Gaussian s3'] = gaussian_img1
    
    # GAUSSIAN with sigma=7
    gaussian_img2 = nd.gaussian_filter(img, sigma=7)
    gaussian_img3 = gaussian_img2.reshape(-1)
    df['Gaussian s7'] = gaussian_img3
    
    # MEDIAN with sigma=3
    median_img = nd.median_filter(img, size=3)
    median_img1 = median_img.reshape(-1)
    df['Median s3'] = median_img1
    
    # VARIANCE with size=3
    variance_img = nd.generic_filter(img, np.var, size=3)
    variance_img1 = variance_img.reshape(-1)
    df['Variance s3'] = variance_img1  # Add column to original dataframe
 
######################################                    
# Update dataframe for images to include details for each image in the loop
    image_dataset = image_dataset.append(df)

mask_dataset = pd.DataFrame()  # Create dataframe to capture mask info.
 
mask_path = "images/train_masks/"    
for mask in os.listdir(mask_path):  # iterate through each file to perform some action
    print(mask)
    
    df2 = pd.DataFrame()  # Temporary dataframe to capture info for each mask in the loop
    input_mask = cv2.imread(mask_path + mask)
    
    # Check if the input mask is RGB or grey and convert to grey if RGB
    if input_mask.ndim == 3 and input_mask.shape[-1] == 3:
        label = cv2.cvtColor(input_mask,cv2.COLOR_BGR2GRAY)
    elif input_mask.ndim == 2:
        label = input_mask
    else:
        raise excerption("The module works only with grayscale and RGB images!")
 
    # Add pixel values to the data frame
    label_values = label.reshape(-1)
    df2['Label_Value'] = label_values
    df2['Mask_Name'] = mask
    
    mask_dataset = mask_dataset.append(df2)  # Update mask dataframe with all the info from each mask

dataset = pd.concat([image_dataset, mask_dataset], axis=1)  # Concatenate both image and mask datasets
 
# If you expect image and mask names to be the same this is where we can perform sanity check
# dataset['Image_Name'].equals(dataset['Mask_Name'])   
# If we do not want to include pixels with value 0 
# e.g. Sometimes unlabeled pixels may be given a value 0.
dataset = dataset[dataset.Label_Value != 0]
 
# Assign training features to X and labels to Y
# Drop columns that are not relevant for training (non-features)
X = dataset.drop(labels = ["Image_Name", "Mask_Name", "Label_Value"], axis=1) 
 
# Assign label values to Y (our prediction)
Y = dataset["Label_Value"].values 
 
# Split data into train and test to verify accuracy after fitting the model. 
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=20)

# Import training classifier
from sklearn.ensemble import RandomForestClassifier
# Instantiate model with n number of decision trees
model = RandomForestClassifier(n_estimators = 50, random_state = 42)
 
# Train the model on training data
model.fit(X_train, y_train)

from sklearn import metrics
 
prediction_test = model.predict(X_test)
# Check accuracy on test dataset. 
print("Accuracy = ", metrics.accuracy_score(y_test, prediction_test))

# You can store the model for future use. In fact, this is how you do machine elarning
# Train on training images, validate on test images and deploy the model on unknown images. 
# Save the trained model as pickle string to disk for future use
model_name = "sandstone_model"
pickle.dump(model, open(model_name, 'wb'))